package someTestExcemple.huaweiOd.container.queue;
//https://blog.csdn.net/guorui_java/article/details/131886137

import java.util.*;

//华为OD机试 - 模拟消息队列（Java 2025 A卷 100分）
/*一、题目描述
        让我们来模拟一个消息队列的运作，有一个发布者和若干个消费者，发布者会在给定的时刻向消息队列发送消息。

        若此时消息队列有消费者订阅，这个消息会被发送到订阅的消费者中优先级最高(输入中消费者按优先级升序排列)的一个;
        若此时没有订阅的消费者，该消息被消息队列丢弃。
        消费者则会在给定的时刻订阅消息队列或取消订阅。

        当消息发送和订阅发生在同一时刻时，先处理订阅操作，即同一时刻订阅的消费者成为消息发送的候选。
        当消息发送和取消订阅发生在同一时刻时，先处理取消订阅操作，即消息不会被发送到同一时刻取消订阅的消费者。
        二、输入描述
        输入为两行。

        第一行为2N 个正整数，代表发布者发送的N个消息的时刻和内容(为方便解折，消息内容也用正整教表示)。第一个数字是第一个消息的发送时刻，第二个数字是第一个消息的内容，以此类推。用例保证发送时刻不会重复，但注意消息并没有按照发送时刻排列。

        第二行为2M个正整数，代表M个消费者订阅和取消订阅的时刻。第一个数字是第一个消费者订阅的时刻，第二个数字是第一个消费者取消订阅的时刻，以此类堆。用例保证每个消费者的取消订阅时刻大于订阅时刻，消费者按优先级 升席排列。

        两行的数字都由空格分隔。N不超过100，M不超过10，每行的长度不超过1000字符。

        三、输出描述
        输出为M行，依次为M个消费者收到的消息内容，消息内容按收到的顺序排列，且由空格分隔;
        若某个消费者没有收到任何消息，则对应的行输出−1。

        四、测试用例
        测试用例1
        1、输入
        5 50 6 60
        1 5 2 3

        2、输出
        -1
        -1*/
public class MockMessageQueue {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input1 = sc.nextLine().split(" ");
        String[] input2 = sc.nextLine().split(" ");
        sc.close();
        //消息数量
        int messageNum = input1.length/2;
        //消费者数量
        int consumerNum = input2.length/2;
        int[][] messagePusher = new int[messageNum][2];
        int[][] consumer = new int[consumerNum][2];
        //发布时刻 -消息
        for(int i=0;i<messageNum;i++) {
            messagePusher[i][0] = Integer.parseInt(input1[i*2]);
            messagePusher[i][1] = Integer.parseInt(input1[i*2+1]);
        }
        //订阅时刻 - 取消订阅时刻
        for(int i=0;i< consumerNum;i++) {
            consumer[i][0] = Integer.parseInt(input2[2*i]);
            consumer[i][1] = Integer.parseInt(input2[2*i+1]);
        }
        //按发布时间排序
        Arrays.sort(messagePusher,((o1, o2) -> {
            return o1[0] -o2[0];
        }));
        //最终消费结果 消费者索引---消息列表
        List<List<Integer>> result = new ArrayList<>();
        for(int i=0;i<consumerNum;i++) {
            result.add(new ArrayList<>());
        }
        for(int i=0;i<messageNum;i++) {
            //按优先级，后面的消费者优先级高
            for(int j=consumer.length-1;j>=0;j--) {
                if(consumer[j][0] <= messagePusher[i][0] && consumer[j][1] > messagePusher[i][0]) {
                    result.get(j).add(messagePusher[i][1]);
                    break; //确保只被最高优先级的消费者消费一次
                }
            }
        }

        for(int i=0;i<consumerNum;i++) {
            if(result.get(i).isEmpty()) {
                System.out.println(-1);
            } else {
                List<Integer> messages = result.get(i);
                StringJoiner joiner = new StringJoiner(" ");
                for (int j=0;j<messages.size();j++) {
                    joiner.add(String.valueOf(messages.get(j)));
                }
                System.out.println(joiner);
            }
        }

    }
}
/**
 * 1、输入
 * 2 200 1 100 4 400 5 500 3 300
 * 1 7 2 3
 *
 * 2、输出
 * 100 300 400 500
 * 200
 */